home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / xwindows / demos / xfract_1.z / xfract_1 / xfractint-1.06 / general.c < prev    next >
C/C++ Source or Header  |  1992-09-28  |  19KB  |  928 lines
  1. /* generalasm.c
  2.  * This file contains routines to replace general.asm.
  3.  *
  4.  * This file Copyright 1991 Ken Shirriff.  It may be used according to the
  5.  * fractint license conditions, blah blah blah.
  6.  */
  7.  
  8. #include <string.h>
  9. #ifndef NOBSTRING
  10. /* If this gives you an error, read the README and modify the Makefile. */
  11. #include <bstring.h>
  12. #endif
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <sys/types.h>
  16. #include <sys/time.h>
  17. #include "fractint.h"
  18.  
  19. int overflow = 0;
  20.  
  21. char boxx[9216], boxy[4096];
  22. char boxvalues[2048];
  23. char tstack[4096];
  24.  
  25. extern int tabmode;
  26.  
  27. int DivideOverflow = 0;
  28. int iit=0;
  29. int cpu=0;        /* cpu type: 86, 186, 286, or 386 */
  30. #ifndef XFRACT
  31. int fpu=0;        /* fpu type: 0, 87, 287, 387 */
  32. #else
  33. int fpu=1;
  34. #endif
  35.  
  36. char *extraseg=0;        /* extra 64K segment (allocated by init) */
  37. /* ********************** Mouse Support Variables ************************** */
  38.  
  39. int lookatmouse=0;    /* see notes at mouseread routine */
  40. int savebase=0;        /* base clock ticks */ 
  41. int saveticks=0;    /* save after this many ticks */ 
  42. int finishrow=0;    /* save when this row is finished */
  43.  
  44. int inside_help = 0;
  45.  
  46. extern int slides;    /* 1 for playback */
  47.  
  48. void toextra(tooffset, fromaddr, fromcount)
  49. int tooffset;
  50. char *fromaddr;
  51. int fromcount;
  52. {
  53.     bcopy(fromaddr,(char *)(extraseg+tooffset),fromcount);
  54. }
  55.  
  56. void fromextra(fromoffset, toaddr, tocount)
  57. int fromoffset;
  58. char *toaddr;
  59. int tocount;
  60. {
  61.     bcopy((char *)(extraseg+fromoffset),toaddr,tocount);
  62. }
  63.  
  64. int
  65. cmpextra(cmpoffset,cmpaddr,cmpcount)
  66. int cmpoffset;
  67. char *cmpaddr;
  68. int cmpcount;
  69. {
  70.     return bcmp((char *)(extraseg+cmpoffset),cmpaddr,cmpcount);
  71. }
  72.  
  73. /*
  74. ; ****************** Function initasmvars() *****************************
  75. */
  76. void
  77. initasmvars()
  78. {
  79.     if (cpu!=0) return;
  80.     overflow = 0;
  81.     extraseg = malloc(0x18000);
  82.  
  83.     /* set cpu type */
  84.     cpu = 1;
  85.  
  86.     /* set fpu type */
  87. #ifndef XFRACT
  88.     fpu = 0;
  89. #else
  90.     fpu = 1;
  91. #endif
  92.  
  93. }
  94.  
  95. void fpe_handler(int signum)
  96. {
  97.     overflow = 1;
  98. }
  99.  
  100. /*
  101. ;
  102. ;       32-bit integer multiply routine with an 'n'-bit shift.
  103. ;       Overflow condition returns 0x7fffh with overflow = 1;
  104. ;
  105. ;       long x, y, z, multiply();
  106. ;       int n;
  107. ;
  108. ;       z = multiply(x,y,n)
  109. ;
  110. */
  111. static float
  112. tofloat(x,n)
  113. long x;
  114. int n;
  115. {
  116.     return (float)x/(float)(1<<n);
  117. }
  118. /*
  119.  * 32 bit integer multiply with n bit shift.
  120.  * Note that we fake integer multiplication with floating point
  121.  * multiplication.
  122.  */
  123. long
  124. multiply(x, y, n)
  125. long x,y;
  126. int n;
  127. {
  128.     register long l;
  129.     l = ((float)x)* ((float)y)/(float)(1<<n);
  130.     if (l==0x7fffffff) {
  131.     overflow = 1;
  132.     }
  133.     return l;
  134. }
  135.  
  136. /*
  137. ;
  138. ;       32-bit integer divide routine with an 'n'-bit shift.
  139. ;       Overflow condition returns 0x7fffh with overflow = 1;
  140. ;
  141. ;       z = divide(x,y,n);       z = x / y;
  142. */
  143. long
  144. divide(x,y,n)
  145. long x,y;
  146. int n;
  147. {
  148.     return (long) ( ((float)x)/ ((float)y)*(float)(1<<n));
  149. }
  150.  
  151. /*
  152. ; ****************** Function getakey() *****************************
  153. ; **************** Function keypressed() ****************************
  154.  
  155. ;       'getakey()' gets a key from either a "normal" or an enhanced
  156. ;       keyboard.   Returns either the vanilla ASCII code for regular
  157. ;       keys, or 1000+(the scan code) for special keys (like F1, etc)
  158. ;       Use of this routine permits the Control-Up/Down arrow keys on
  159. ;       enhanced keyboards.
  160. ;
  161. ;       The concept for this routine was "borrowed" from the MSKermit
  162. ;       SCANCHEK utility
  163. ;
  164. ;       'keypressed()' returns a zero if no keypress is outstanding,
  165. ;       and the value that 'getakey()' will return if one is.  Note
  166. ;       that you must still call 'getakey()' to flush the character.
  167. ;       As a sidebar function, calls 'help()' if appropriate, or
  168. ;       'tab_display()' if appropriate.
  169. ;       Think of 'keypressed()' as a super-'kbhit()'.
  170. */
  171. int keybuffer = 0;
  172. keypressed() {
  173.     int ch;
  174.     ch = getkeynowait();
  175.     if (!ch) return 0;
  176.     keybuffer = ch;
  177.     if (ch==F1 && helpmode) {
  178.     keybuffer = 0;
  179.     inside_help = 1;
  180.     help(0);
  181.     inside_help = 0;
  182.     restore_active_ovly();
  183.     return 0;
  184.     } else if (ch==TAB && tabmode) {
  185.     keybuffer = 0;
  186.     tab_display();
  187.     restore_active_ovly();
  188.     return 0;
  189.     }
  190.     return ch;
  191. }
  192.  
  193. /* Wait for a key.
  194.  * This should be used instead of:
  195.  * while (!keypressed()) {}
  196.  * If timeout=1, waitkeypressed will time out after .5 sec.
  197.  */
  198. waitkeypressed(timeout)
  199. int timeout;
  200. {
  201.     int status;
  202.     while (!keybuffer) {
  203.     keybuffer = getkeyint(1);
  204.     if (timeout) break;
  205.     }
  206.     return keypressed();
  207. }
  208.  
  209. /*
  210.  * This routine returns a key, ignoring F1
  211.  */
  212. getakeynohelp() {
  213.     int ch;
  214.     while (1) {
  215.     ch = getakey();
  216.     if (ch != F1) break;
  217.     }
  218.     return ch;
  219. }
  220. /* 
  221.  * This routine returns a keypress
  222.  */
  223. getakey()
  224. {
  225.     int ch;
  226.  
  227.     do {
  228.     ch = getkeyint(1);
  229.     } while (ch==0);
  230.     return ch;
  231. }
  232.  
  233. /*
  234.  * This routine returns the current key, or 0.
  235.  */
  236. getkeynowait() {
  237.     return getkeyint(0);
  238. }
  239.  
  240. /*
  241.  * This is the low level key handling routine.
  242.  * If block is set, we want to block before returning, since we are waiting
  243.  * for a key press.
  244.  * We also have to handle the slide file, etc.
  245.  */
  246.  
  247. getkeyint(block)
  248. int block;
  249. {
  250.     int ch;
  251.     int curkey;
  252.     if (keybuffer) {
  253.     ch = keybuffer;
  254.     keybuffer = 0;
  255.     return ch;
  256.     }
  257.     curkey = xgetkey(0);
  258.     if (slides==1 && curkey == ESC) {
  259.     stopslideshow();
  260.     return 0;
  261.     }
  262.  
  263.     if (curkey==0 && slides==1) {
  264.     curkey = slideshw();
  265.     }
  266.  
  267.     if (curkey==0 && block) {
  268.     curkey = xgetkey(1);
  269.     if (slides==1 && curkey == ESC) {
  270.         stopslideshow();
  271.         return 0;
  272.     }
  273.     }
  274.  
  275.     if (curkey && slides==2) {
  276.     recordshw(curkey);
  277.     }
  278.  
  279.     return curkey;
  280. }
  281.  
  282. /*
  283. ; ****************** Function buzzer(int buzzertype) *******************
  284. ;
  285. ;       Sound a tone based on the value of the parameter
  286. ;
  287. ;       0 = normal completion of task
  288. ;       1 = interrupted task
  289. ;       2 = error contition
  290.  
  291. ;       "buzzer()" codes:  strings of two-word pairs
  292. ;               (frequency in cycles/sec, delay in milliseconds)
  293. ;               frequency == 0 means no sound
  294. ;               delay     == 0 means end-of-tune
  295. */
  296. void
  297. buzzer(buzzertype)
  298. int buzzertype;
  299. {
  300.     printf("\007");
  301.     fflush(stdout);
  302.     if (buzzertype==0) {
  303.     redrawscreen();
  304.     }
  305. }
  306.  
  307. /*
  308. ; ***************** Function delay(int delaytime) ************************
  309. ;
  310. ;       performs a delay loop for 'delaytime' milliseconds
  311. */
  312. void
  313. delay(delaytime)
  314. int delaytime;
  315. {
  316.     static struct timeval delay;
  317.     delay.tv_sec = delaytime/1000;
  318.     delay.tv_usec = (delaytime%1000)*1000;
  319.     (void) select(0, (int *) 0, (int *) 0, (int *) 0, &delay);
  320. }
  321.  
  322. /*
  323. ; ************** Function tone(int frequency,int delaytime) **************
  324. ;
  325. ;       buzzes the speaker with this frequency for this amount of time
  326. */
  327. void
  328. tone(frequency, delaytime)
  329. int frequency, delaytime;
  330. {
  331. }
  332.  
  333. /*
  334. ; ************** Function snd(int hertz) and nosnd() **************
  335. ;
  336. ;       turn the speaker on with this frequency (snd) or off (nosnd)
  337. ;
  338. ; *****************************************************************
  339. */
  340. void
  341. snd(hertz)
  342. int hertz;
  343. {
  344. }
  345.  
  346. void
  347. nosnd()
  348. {}
  349.  
  350. /*
  351. ; long readticker() returns current bios ticker value
  352. */
  353. long
  354. readticker()
  355. {
  356.     return clock_ticks();
  357. }
  358.  
  359. /*
  360. ; ************************* Far Segment RAM Support **************************
  361. ;
  362. ;
  363. ;       farptr = (char far *)farmemalloc(long bytestoalloc);
  364. ;       (void)farmemfree(farptr);
  365. */
  366.  
  367. VOIDPTR 
  368. farmemalloc(len)
  369. long len;
  370. {
  371.     return (VOIDPTR )malloc((unsigned)len);
  372. }
  373.  
  374. void
  375. farmemfree(addr)
  376. VOIDPTR addr;
  377. {
  378.     free((char *)addr);
  379. }
  380.  
  381. erasesegment(segaddress,segvalue)
  382. {
  383. }
  384.  
  385.  
  386. int
  387. farread(handle, buf, len)
  388. int handle;
  389. VOIDPTR buf;
  390. unsigned len;
  391. {
  392.     return read(handle, buf, len);
  393. }
  394.  
  395. int
  396. farwrite(handle, buf, len)
  397. int handle;
  398. VOIDPTR buf;
  399. unsigned len;
  400. {
  401.     return write(handle,buf,len);
  402. }
  403.  
  404.  
  405. long
  406. normalize(ptr)
  407. char *ptr;
  408. {
  409.     return (long) ptr;
  410. }
  411.  
  412. /*
  413. ; *************** Far string/memory functions *********
  414. */
  415. int
  416. far_strlen (a)
  417. char *a;
  418. {
  419.     return strlen(a);
  420. }
  421.  
  422.  
  423. int
  424. far_strcpy (a,b)
  425. char *a,*b;
  426. {
  427.     return (int)strcpy(a,b);
  428. }
  429.  
  430. int
  431. far_strcmp (a,b)
  432. char *a, *b;
  433. {
  434.     return strcmp(a,b);
  435. }
  436.  
  437. int
  438. far_stricmp(a,b)
  439. char *a,*b;
  440. {
  441.     return stricmp(a,b);
  442. }
  443.  
  444. int
  445. far_strnicmp(a,b,n)
  446. char *a,*b;
  447. int n;
  448. {
  449.     return strnicmp(a,b,n);
  450. }
  451.  
  452. int
  453. far_strcat (a,b)
  454. char *a,*b;
  455. {
  456.     return (int)strcat(a,b);
  457. }
  458.  
  459. int
  460. far_memset ( a,c,len)
  461. VOIDPTR a;
  462. int c